'''2,闭包'''
# nonlocal--在内嵌函数中使用
# __globals__是函数的一个属性，函数所属的模块(当前这个.py文件)的全局变量字典
# print(函数.__globals__["变量"])
# __closure__是闭包的一个属性，里面存储了，闭包函数使用到的外部函数的局部变量
# print(函数.__closure__[0].cell_contents)
#cell_contents 闭包中的单元格内容，也就是内嵌函数应用到外部函数的局部变量的值
# 闭包的示例，计算器的功能
# def outer(total):
#     def inner(step):
#         nonlocal total#告诉解释器，此处的total变量要往上一层查找，也就是外部函数的
#         total += step
#         return total
#     return inner
# f = outer(0)#调用外部函数，返回一个函数，这个函数就是一个闭包，0表示从0开始记数
# print(f.__closure__[0].cell_contents)#0
# #__closure__在此上是内嵌函数使用外部函数的total
# f(1)
# print(f.__closure__[0].cell_contents)#1
# f(1)
# print(f.__closure__[0].cell_contents)#2
# f(2)
# print(f.__closure__[0].cell_contents)#4
#
# print("~~~~~~以下相当于另一个线程~~~~~~~~~~")
# f1 = outer(100)
# print(f1.__closure__[0].cell_contents)#在100的基础上开始计数
# f1(10)
# print(f1.__closure__[0].cell_contents)#110
# f(20)
# print(f1.__closure__[0].cell_contents)#130




'''函数装饰器 decorators'''
# 装饰一个函数，参数传入一个函数，返回的也是一个函数
# def mydeco(fn):
#     def fx():
#         print("++++++++++")
#         fn()#相当于被装饰的函数
#         print("----------")
#     return fx
#
# def mydeco2(fn):
#     def fx():
#         print("~~~~~~~~~~~")
#         fn()
#     return fx
#
# @mydeco
# @mydeco2
# def myfun():
#     print("这是自定义的函数")
# myfun()




# 模拟银行系统，当存钱或取钱时，装饰一段话：欢迎XX来办理XX业务

#装饰器
# def message_send(fn):
#     def fx(name,money):
#         print("欢迎",name,"来银行办理业务")
#         fn(name,money)#fn表示被装饰的函数
#         print(name,"办理了",money,"元的业务")
#     return fx
#
# #装饰器：表权限验证
# def pviviledged_check(fn):
#     def fx(password,num):
#         print("正在进行验证")
#         if password == 123:
#             print("验证成功")
#             fn(password,num)#相当于执行那个被装饰的函数
#         else:
#             print("验证失败")
#     return fx
# @message_send
# @pviviledged_check
# def get_money(password,num):
#     print("取钱成功~~~~")
#     print("~~~~~~~~~~~~~~~~~~~~~~~")
# get_money(1213,10000)
# #表示存钱
# @message_send
# def save_money(name,money):
#     print(name,"存了",money,"元")
# save_money("张三",100)




'''函数的文档字符串'''
# 在函数内部，第一个没有赋值给任何遍历的字符串，用来解释这个函数

'''函数的__doc__属性'''
# 存储了函数的文档字符串

'''函数的__name__属性'''
# 存了绑定了函数的变量名的字符串

'''函数的globals__属性'''
# 存储了函数所在模块的:全部变量，字典


# a = 1
# b = 2
# def f1():
#     """f1的普通字符串"""
#     print("f1函数")
#
# print(f1.__doc__)#文档字符串
# print(f1.__name__)#f1
# f2 = f1
# print(f2.__name__)#f1和f2都是变量，他们都绑定了函数f1
# print(f1.__globals__)


'''函数的标准写法'''
# [@装饰器1]
# [@装饰器2]
# def 函数名([位置形参],[*元组形参],[命名关键字,[**字典形参]])：
#         '''函数的文档字符串'''
#         函数体

# L = [1,2,3]
# # 函数的缺省值在定义的时候就确定了，而不是每一次调用时才确定
# # 也就是说在定义函数的时候，形参lst指向了[]在内存的地址
# # 每一次调用f函数时，它的lst形参都指向了同一列表对象
# def f(n,lst=[]):#列表是个缺省值
#     lst.append(n)
#     print(lst)
#
# f(4,L)#1234
# f(5,L)#12345
# f(100)#100
# f(200)#100,200






'''模块'''
# 模块是一个包含了一系列的数据，函数，类 组成程序表，通常以.py结尾
# 分类：builtins（内建模块），在解析器自动使用；标准库模块，安装Python解释器后直接使用
#      第三方模块：手动安装，pip包管理工具；用户自定义模块
# import math
# import 模块名[as 新名]
# from 模块名 import 属性名
# from 模块名 import *

# from可以将某个模块的某个属性，或者所有属性引入到当前作用域中，如果采用这样的方式
# 在当前作用域中可以直接使用属性，而不需要使用模块.属性的方式

# print(dir(math))#返回以字符串组成的列表，表示该模块下所有的变量
# print(help(math))#返回该模块下所有的文档字符串
# math.pow(1,2)#如果接受两个参数，就是计算x的y次方，如果接收三个参数，再对三个参数取余

# import math
# n = float(input("请输入正方形的周长:"))
# m = math.pow(n/4,2)#pow表平方
# print("正形的面积为：",m)
#
# r = float(input("请输入圆的半径:"))
# m = math.pi*math.pow(r,r)
# print("圆的面积为：",m)
#
# s = float(input("请输入正方形的面积:"))
# m = math.sqrt(s)*4
# print("正方形的周长为：",m)




'''dir函数，返回字符串组成的列表'''
# dir(math):参数是一个模块，返回所有的变量组成的列表
#           参数如果是一个类对象，返回其所有的属性
#           参数是其他对象，返回所有的变量


'''时间元组：time模块'''
import time
import datetime
# print(dir(time))

# 计算机领域中时间元年1970.1.100：00：00
# time模块中维护了一个时间元组，9个数组组成的元组，
# 四位数的年份，如果值小于100，会自动补上1900
# 月 1~12
# 日 1~31
# 时 0~23
# 分 0~59
# 秒 0~59
# 星期0~6
# 元旦开始日1~366
# 夏令修正时10 -1

# time.mktime(tuple)--将时间元组转换成秒数
# time.localtime([seconds])--将秒数转换成时间元组
# time.sleep(seconds)--线程休眠

# year = int(input("请输入年："))
# month = int(input("请输入月："))
# day = int(input("请输入日："))
# birthday = (year,month,day,0,0,0,0,0,0)
# birthday_second = time.mktime(birthday)
# print(birthday_second)
# current_time = time.time()
# print(current_time)
# print((current_time - birthday_second)/60/60/24)


# year = int(input("请输入年："))
# month = int(input("请输入月："))
# day = int(input("请输入日："))
# birthday = (year,month,day,0,0,0,0,0,0)
# birthday_second = time.mktime(birthday)#将时间元组转换成秒数
# birthday = time.localtime(birthday_second)#秒数 转换成时间元组
# print(birthday)


# 在控制台每秒打印当前时间（格式：HH:MM:SS），持续运行
# while True:
#     current_time = datetime.datetime.now()
#     print(current_time)
#     time.sleep(1)

# while True:
#     current_tuple = time.localtime()
#     current_list = current_tuple[3:6]
#     print(current_list[0],":",current_list[1],":",current_list[2])
#     time.sleep(1)


hour = int(input("请输入闹钟的时："))
min = int(input("请输入闹钟的分："))
second = int(input("请输入闹钟的秒："))
clock = (hour,min,second)
while True:
    current_tuple = time.localtime()
    current_t = current_tuple[3:6]
    print(current_t[0],":",current_t[1],":",current_t[2])
    time.sleep(1)
    if current_t == clock:
        print("到时间了!!!!!!!!!!!")
        break



